// Generated from D:/IDEAWork/play/private/yu-gi-oh/src/main/resources/antlr4\EffectParser.g4 by ANTLR 4.8
package com.zfast.yugioh.antlr4.effect;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class EffectParser extends Parser {
	static { RuntimeMetaData.checkVersion("4.8", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		SELECT=1, UPDATE=2, SET=3, FROM=4, TO=5, WHERE=6, LIMIT=7, IF=8, AS=9, 
		SEMICOLON=10, DOT=11, COMMA=12, LEFT_PAREN=13, RIGHT_PAREN=14, LEFT_BRACES=15, 
		RIGHT_BRACES=16, COLON=17, PIPE=18, EQ=19, NEQ=20, LT=21, LTE=22, GT=23, 
		GTE=24, OR=25, AND=26, PLUS=27, MINUS=28, ASTERISK=29, SLASH=30, ID=31, 
		OBJECT=32, OBJECTARRYS=33, INT=34, STRING=35, WS=36;
	public static final int
		RULE_exprExt1 = 0, RULE_orgExpression = 1, RULE_coreAct = 2, RULE_aimObject = 3, 
		RULE_aimJudge = 4, RULE_targetObjectArrys = 5, RULE_aimObjectArrys = 6, 
		RULE_targetJudge = 7, RULE_limitStr = 8, RULE_expr = 9, RULE_set_expr = 10, 
		RULE_where_expr = 11;
	private static String[] makeRuleNames() {
		return new String[] {
			"exprExt1", "orgExpression", "coreAct", "aimObject", "aimJudge", "targetObjectArrys", 
			"aimObjectArrys", "targetJudge", "limitStr", "expr", "set_expr", "where_expr"
		};
	}
	public static final String[] ruleNames = makeRuleNames();

	private static String[] makeLiteralNames() {
		return new String[] {
			null, "'SELECT'", "'UPDATE'", "'SET'", "'FROM'", "'TO'", "'WHERE'", "'LIMIT'", 
			"'IF'", "'AS'", "';'", "'.'", "','", "'('", "')'", "'{'", "'}'", "':'", 
			"'|'", null, null, "'<'", null, "'>'", null, "'OR'", "'AND'", "'+'", 
			"'-'", "'*'", "'/'"
		};
	}
	private static final String[] _LITERAL_NAMES = makeLiteralNames();
	private static String[] makeSymbolicNames() {
		return new String[] {
			null, "SELECT", "UPDATE", "SET", "FROM", "TO", "WHERE", "LIMIT", "IF", 
			"AS", "SEMICOLON", "DOT", "COMMA", "LEFT_PAREN", "RIGHT_PAREN", "LEFT_BRACES", 
			"RIGHT_BRACES", "COLON", "PIPE", "EQ", "NEQ", "LT", "LTE", "GT", "GTE", 
			"OR", "AND", "PLUS", "MINUS", "ASTERISK", "SLASH", "ID", "OBJECT", "OBJECTARRYS", 
			"INT", "STRING", "WS"
		};
	}
	private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);

	/**
	 * @deprecated Use {@link #VOCABULARY} instead.
	 */
	@Deprecated
	public static final String[] tokenNames;
	static {
		tokenNames = new String[_SYMBOLIC_NAMES.length];
		for (int i = 0; i < tokenNames.length; i++) {
			tokenNames[i] = VOCABULARY.getLiteralName(i);
			if (tokenNames[i] == null) {
				tokenNames[i] = VOCABULARY.getSymbolicName(i);
			}

			if (tokenNames[i] == null) {
				tokenNames[i] = "<INVALID>";
			}
		}
	}

	@Override
	@Deprecated
	public String[] getTokenNames() {
		return tokenNames;
	}

	@Override

	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}

	@Override
	public String getGrammarFileName() { return "EffectParser.g4"; }

	@Override
	public String[] getRuleNames() { return ruleNames; }

	@Override
	public String getSerializedATN() { return _serializedATN; }

	@Override
	public ATN getATN() { return _ATN; }

	public EffectParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}

	public static class ExprExt1Context extends ParserRuleContext {
		public ExprExt1Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_exprExt1; }
	 
		public ExprExt1Context() { }
		public void copyFrom(ExprExt1Context ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class OrgExprContext extends ExprExt1Context {
		public OrgExpressionContext orgExpression() {
			return getRuleContext(OrgExpressionContext.class,0);
		}
		public List<ExprExt1Context> exprExt1() {
			return getRuleContexts(ExprExt1Context.class);
		}
		public ExprExt1Context exprExt1(int i) {
			return getRuleContext(ExprExt1Context.class,i);
		}
		public OrgExprContext(ExprExt1Context ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterOrgExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitOrgExpr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitOrgExpr(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class IfContext extends ExprExt1Context {
		public TerminalNode IF() { return getToken(EffectParser.IF, 0); }
		public TerminalNode LEFT_PAREN() { return getToken(EffectParser.LEFT_PAREN, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public TerminalNode RIGHT_PAREN() { return getToken(EffectParser.RIGHT_PAREN, 0); }
		public TerminalNode LEFT_BRACES() { return getToken(EffectParser.LEFT_BRACES, 0); }
		public ExprExt1Context exprExt1() {
			return getRuleContext(ExprExt1Context.class,0);
		}
		public TerminalNode RIGHT_BRACES() { return getToken(EffectParser.RIGHT_BRACES, 0); }
		public IfContext(ExprExt1Context ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterIf(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitIf(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitIf(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExprExt1Context exprExt1() throws RecognitionException {
		ExprExt1Context _localctx = new ExprExt1Context(_ctx, getState());
		enterRule(_localctx, 0, RULE_exprExt1);
		try {
			int _alt;
			setState(39);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case SELECT:
			case UPDATE:
				_localctx = new OrgExprContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(24);
				orgExpression();
				setState(28);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,0,_ctx);
				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						setState(25);
						exprExt1();
						}
						} 
					}
					setState(30);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,0,_ctx);
				}
				}
				break;
			case IF:
				_localctx = new IfContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(31);
				match(IF);
				setState(32);
				match(LEFT_PAREN);
				setState(33);
				expr(0);
				setState(34);
				match(RIGHT_PAREN);
				setState(35);
				match(LEFT_BRACES);
				setState(36);
				exprExt1();
				setState(37);
				match(RIGHT_BRACES);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class OrgExpressionContext extends ParserRuleContext {
		public CoreActContext coreAct() {
			return getRuleContext(CoreActContext.class,0);
		}
		public AimObjectContext aimObject() {
			return getRuleContext(AimObjectContext.class,0);
		}
		public AimJudgeContext aimJudge() {
			return getRuleContext(AimJudgeContext.class,0);
		}
		public TargetObjectArrysContext targetObjectArrys() {
			return getRuleContext(TargetObjectArrysContext.class,0);
		}
		public AimObjectArrysContext aimObjectArrys() {
			return getRuleContext(AimObjectArrysContext.class,0);
		}
		public TargetJudgeContext targetJudge() {
			return getRuleContext(TargetJudgeContext.class,0);
		}
		public LimitStrContext limitStr() {
			return getRuleContext(LimitStrContext.class,0);
		}
		public TerminalNode SEMICOLON() { return getToken(EffectParser.SEMICOLON, 0); }
		public OrgExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_orgExpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterOrgExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitOrgExpression(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitOrgExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final OrgExpressionContext orgExpression() throws RecognitionException {
		OrgExpressionContext _localctx = new OrgExpressionContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_orgExpression);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(41);
			coreAct();
			setState(42);
			aimObject(0);
			setState(43);
			aimJudge();
			setState(44);
			targetObjectArrys();
			setState(45);
			aimObjectArrys();
			setState(46);
			targetJudge();
			setState(47);
			limitStr();
			setState(48);
			match(SEMICOLON);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CoreActContext extends ParserRuleContext {
		public CoreActContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_coreAct; }
	 
		public CoreActContext() { }
		public void copyFrom(CoreActContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class SelectContext extends CoreActContext {
		public TerminalNode SELECT() { return getToken(EffectParser.SELECT, 0); }
		public SelectContext(CoreActContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterSelect(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitSelect(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitSelect(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class UpdateContext extends CoreActContext {
		public TerminalNode UPDATE() { return getToken(EffectParser.UPDATE, 0); }
		public UpdateContext(CoreActContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterUpdate(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitUpdate(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitUpdate(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CoreActContext coreAct() throws RecognitionException {
		CoreActContext _localctx = new CoreActContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_coreAct);
		try {
			setState(52);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case SELECT:
				_localctx = new SelectContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(50);
				match(SELECT);
				}
				break;
			case UPDATE:
				_localctx = new UpdateContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(51);
				match(UPDATE);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AimObjectContext extends ParserRuleContext {
		public AimObjectContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_aimObject; }
	 
		public AimObjectContext() { }
		public void copyFrom(AimObjectContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class ObjectContext extends AimObjectContext {
		public TerminalNode OBJECTARRYS() { return getToken(EffectParser.OBJECTARRYS, 0); }
		public TerminalNode INT() { return getToken(EffectParser.INT, 0); }
		public TerminalNode OBJECT() { return getToken(EffectParser.OBJECT, 0); }
		public TerminalNode ID() { return getToken(EffectParser.ID, 0); }
		public ObjectContext(AimObjectContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterObject(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitObject(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitObject(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class PipeObjectContext extends AimObjectContext {
		public List<AimObjectContext> aimObject() {
			return getRuleContexts(AimObjectContext.class);
		}
		public AimObjectContext aimObject(int i) {
			return getRuleContext(AimObjectContext.class,i);
		}
		public List<TerminalNode> PIPE() { return getTokens(EffectParser.PIPE); }
		public TerminalNode PIPE(int i) {
			return getToken(EffectParser.PIPE, i);
		}
		public List<TerminalNode> OBJECT() { return getTokens(EffectParser.OBJECT); }
		public TerminalNode OBJECT(int i) {
			return getToken(EffectParser.OBJECT, i);
		}
		public List<TerminalNode> ID() { return getTokens(EffectParser.ID); }
		public TerminalNode ID(int i) {
			return getToken(EffectParser.ID, i);
		}
		public PipeObjectContext(AimObjectContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterPipeObject(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitPipeObject(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitPipeObject(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class AsObjectContext extends AimObjectContext {
		public AimObjectContext aimObject() {
			return getRuleContext(AimObjectContext.class,0);
		}
		public TerminalNode AS() { return getToken(EffectParser.AS, 0); }
		public TerminalNode ID() { return getToken(EffectParser.ID, 0); }
		public AsObjectContext(AimObjectContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterAsObject(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitAsObject(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitAsObject(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AimObjectContext aimObject() throws RecognitionException {
		return aimObject(0);
	}

	private AimObjectContext aimObject(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		AimObjectContext _localctx = new AimObjectContext(_ctx, _parentState);
		AimObjectContext _prevctx = _localctx;
		int _startState = 6;
		enterRecursionRule(_localctx, 6, RULE_aimObject, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(59);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case OBJECTARRYS:
				{
				_localctx = new ObjectContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;

				setState(55);
				match(OBJECTARRYS);
				}
				break;
			case INT:
				{
				_localctx = new ObjectContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(56);
				match(INT);
				}
				break;
			case OBJECT:
				{
				_localctx = new ObjectContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(57);
				match(OBJECT);
				}
				break;
			case ID:
				{
				_localctx = new ObjectContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(58);
				match(ID);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			_ctx.stop = _input.LT(-1);
			setState(87);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,8,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(85);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
					case 1:
						{
						_localctx = new AsObjectContext(new AimObjectContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_aimObject);
						setState(61);
						if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
						setState(62);
						match(AS);
						setState(63);
						match(ID);
						}
						break;
					case 2:
						{
						_localctx = new PipeObjectContext(new AimObjectContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_aimObject);
						setState(64);
						if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
						setState(67); 
						_errHandler.sync(this);
						_alt = 1;
						do {
							switch (_alt) {
							case 1:
								{
								{
								setState(65);
								match(PIPE);
								setState(66);
								aimObject(0);
								}
								}
								break;
							default:
								throw new NoViableAltException(this);
							}
							setState(69); 
							_errHandler.sync(this);
							_alt = getInterpreter().adaptivePredict(_input,4,_ctx);
						} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
						}
						break;
					case 3:
						{
						_localctx = new PipeObjectContext(new AimObjectContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_aimObject);
						setState(71);
						if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
						setState(74); 
						_errHandler.sync(this);
						_alt = 1;
						do {
							switch (_alt) {
							case 1:
								{
								{
								setState(72);
								match(PIPE);
								setState(73);
								match(OBJECT);
								}
								}
								break;
							default:
								throw new NoViableAltException(this);
							}
							setState(76); 
							_errHandler.sync(this);
							_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
						} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
						}
						break;
					case 4:
						{
						_localctx = new PipeObjectContext(new AimObjectContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_aimObject);
						setState(78);
						if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
						setState(81); 
						_errHandler.sync(this);
						_alt = 1;
						do {
							switch (_alt) {
							case 1:
								{
								{
								setState(79);
								match(PIPE);
								setState(80);
								match(ID);
								}
								}
								break;
							default:
								throw new NoViableAltException(this);
							}
							setState(83); 
							_errHandler.sync(this);
							_alt = getInterpreter().adaptivePredict(_input,6,_ctx);
						} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
						}
						break;
					}
					} 
				}
				setState(89);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,8,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	public static class AimJudgeContext extends ParserRuleContext {
		public AimJudgeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_aimJudge; }
	 
		public AimJudgeContext() { }
		public void copyFrom(AimJudgeContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class SetObjectBlankContext extends AimJudgeContext {
		public SetObjectBlankContext(AimJudgeContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterSetObjectBlank(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitSetObjectBlank(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitSetObjectBlank(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class SetObjectContext extends AimJudgeContext {
		public TerminalNode SET() { return getToken(EffectParser.SET, 0); }
		public Set_exprContext set_expr() {
			return getRuleContext(Set_exprContext.class,0);
		}
		public SetObjectContext(AimJudgeContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterSetObject(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitSetObject(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitSetObject(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AimJudgeContext aimJudge() throws RecognitionException {
		AimJudgeContext _localctx = new AimJudgeContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_aimJudge);
		try {
			setState(93);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case SET:
				_localctx = new SetObjectContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(90);
				match(SET);
				setState(91);
				set_expr();
				}
				break;
			case FROM:
			case TO:
			case WHERE:
			case LIMIT:
			case SEMICOLON:
				_localctx = new SetObjectBlankContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TargetObjectArrysContext extends ParserRuleContext {
		public TargetObjectArrysContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_targetObjectArrys; }
	 
		public TargetObjectArrysContext() { }
		public void copyFrom(TargetObjectArrysContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class FromContext extends TargetObjectArrysContext {
		public TerminalNode FROM() { return getToken(EffectParser.FROM, 0); }
		public TerminalNode OBJECTARRYS() { return getToken(EffectParser.OBJECTARRYS, 0); }
		public TerminalNode OBJECT() { return getToken(EffectParser.OBJECT, 0); }
		public TerminalNode ID() { return getToken(EffectParser.ID, 0); }
		public FromContext(TargetObjectArrysContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterFrom(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitFrom(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitFrom(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class FromBlankContext extends TargetObjectArrysContext {
		public FromBlankContext(TargetObjectArrysContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterFromBlank(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitFromBlank(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitFromBlank(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TargetObjectArrysContext targetObjectArrys() throws RecognitionException {
		TargetObjectArrysContext _localctx = new TargetObjectArrysContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_targetObjectArrys);
		try {
			setState(102);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
			case 1:
				_localctx = new FromContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(95);
				match(FROM);
				setState(96);
				match(OBJECTARRYS);
				}
				break;
			case 2:
				_localctx = new FromContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(97);
				match(FROM);
				setState(98);
				match(OBJECT);
				}
				break;
			case 3:
				_localctx = new FromContext(_localctx);
				enterOuterAlt(_localctx, 3);
				{
				setState(99);
				match(FROM);
				setState(100);
				match(ID);
				}
				break;
			case 4:
				_localctx = new FromBlankContext(_localctx);
				enterOuterAlt(_localctx, 4);
				{
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AimObjectArrysContext extends ParserRuleContext {
		public AimObjectArrysContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_aimObjectArrys; }
	 
		public AimObjectArrysContext() { }
		public void copyFrom(AimObjectArrysContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class ToBlankContext extends AimObjectArrysContext {
		public ToBlankContext(AimObjectArrysContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterToBlank(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitToBlank(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitToBlank(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class ToContext extends AimObjectArrysContext {
		public TerminalNode TO() { return getToken(EffectParser.TO, 0); }
		public TerminalNode OBJECTARRYS() { return getToken(EffectParser.OBJECTARRYS, 0); }
		public TerminalNode OBJECT() { return getToken(EffectParser.OBJECT, 0); }
		public TerminalNode ID() { return getToken(EffectParser.ID, 0); }
		public ToContext(AimObjectArrysContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterTo(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitTo(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitTo(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AimObjectArrysContext aimObjectArrys() throws RecognitionException {
		AimObjectArrysContext _localctx = new AimObjectArrysContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_aimObjectArrys);
		try {
			setState(111);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
			case 1:
				_localctx = new ToContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(104);
				match(TO);
				setState(105);
				match(OBJECTARRYS);
				}
				break;
			case 2:
				_localctx = new ToContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(106);
				match(TO);
				setState(107);
				match(OBJECT);
				}
				break;
			case 3:
				_localctx = new ToContext(_localctx);
				enterOuterAlt(_localctx, 3);
				{
				setState(108);
				match(TO);
				setState(109);
				match(ID);
				}
				break;
			case 4:
				_localctx = new ToBlankContext(_localctx);
				enterOuterAlt(_localctx, 4);
				{
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TargetJudgeContext extends ParserRuleContext {
		public TargetJudgeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_targetJudge; }
	 
		public TargetJudgeContext() { }
		public void copyFrom(TargetJudgeContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class WhereBlankContext extends TargetJudgeContext {
		public WhereBlankContext(TargetJudgeContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterWhereBlank(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitWhereBlank(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitWhereBlank(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class WhereContext extends TargetJudgeContext {
		public TerminalNode WHERE() { return getToken(EffectParser.WHERE, 0); }
		public Where_exprContext where_expr() {
			return getRuleContext(Where_exprContext.class,0);
		}
		public WhereContext(TargetJudgeContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterWhere(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitWhere(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitWhere(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TargetJudgeContext targetJudge() throws RecognitionException {
		TargetJudgeContext _localctx = new TargetJudgeContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_targetJudge);
		try {
			setState(116);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case WHERE:
				_localctx = new WhereContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(113);
				match(WHERE);
				setState(114);
				where_expr(0);
				}
				break;
			case LIMIT:
			case SEMICOLON:
				_localctx = new WhereBlankContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LimitStrContext extends ParserRuleContext {
		public LimitStrContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_limitStr; }
	 
		public LimitStrContext() { }
		public void copyFrom(LimitStrContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class LimitContext extends LimitStrContext {
		public TerminalNode LIMIT() { return getToken(EffectParser.LIMIT, 0); }
		public Set_exprContext set_expr() {
			return getRuleContext(Set_exprContext.class,0);
		}
		public LimitContext(LimitStrContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterLimit(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitLimit(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitLimit(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class LimitBlankContext extends LimitStrContext {
		public LimitBlankContext(LimitStrContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterLimitBlank(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitLimitBlank(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitLimitBlank(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LimitStrContext limitStr() throws RecognitionException {
		LimitStrContext _localctx = new LimitStrContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_limitStr);
		try {
			setState(121);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LIMIT:
				_localctx = new LimitContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(118);
				match(LIMIT);
				setState(119);
				set_expr();
				}
				break;
			case SEMICOLON:
				_localctx = new LimitBlankContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ExprContext extends ParserRuleContext {
		public ExprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expr; }
	 
		public ExprContext() { }
		public void copyFrom(ExprContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class Operator_SLASHContext extends ExprContext {
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public TerminalNode SLASH() { return getToken(EffectParser.SLASH, 0); }
		public Operator_SLASHContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterOperator_SLASH(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitOperator_SLASH(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitOperator_SLASH(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class Operator_COLONContext extends ExprContext {
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public TerminalNode COLON() { return getToken(EffectParser.COLON, 0); }
		public Operator_COLONContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterOperator_COLON(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitOperator_COLON(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitOperator_COLON(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class Operator_GTEContext extends ExprContext {
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public TerminalNode GTE() { return getToken(EffectParser.GTE, 0); }
		public Operator_GTEContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterOperator_GTE(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitOperator_GTE(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitOperator_GTE(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class Operator_NEQContext extends ExprContext {
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public TerminalNode NEQ() { return getToken(EffectParser.NEQ, 0); }
		public Operator_NEQContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterOperator_NEQ(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitOperator_NEQ(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitOperator_NEQ(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class Operator_Expr1Context extends ExprContext {
		public TerminalNode INT() { return getToken(EffectParser.INT, 0); }
		public Operator_Expr1Context(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterOperator_Expr1(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitOperator_Expr1(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitOperator_Expr1(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class Operator_Expr0Context extends ExprContext {
		public TerminalNode STRING() { return getToken(EffectParser.STRING, 0); }
		public Operator_Expr0Context(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterOperator_Expr0(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitOperator_Expr0(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitOperator_Expr0(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class Operator_GTContext extends ExprContext {
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public TerminalNode GT() { return getToken(EffectParser.GT, 0); }
		public Operator_GTContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterOperator_GT(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitOperator_GT(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitOperator_GT(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class Operator_Expr2Context extends ExprContext {
		public TerminalNode OBJECT() { return getToken(EffectParser.OBJECT, 0); }
		public Operator_Expr2Context(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterOperator_Expr2(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitOperator_Expr2(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitOperator_Expr2(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class Operator_Expr4Context extends ExprContext {
		public TerminalNode ID() { return getToken(EffectParser.ID, 0); }
		public Operator_Expr4Context(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterOperator_Expr4(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitOperator_Expr4(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitOperator_Expr4(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class Operator_LTEContext extends ExprContext {
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public TerminalNode LTE() { return getToken(EffectParser.LTE, 0); }
		public Operator_LTEContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterOperator_LTE(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitOperator_LTE(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitOperator_LTE(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class Operator_LTContext extends ExprContext {
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public TerminalNode LT() { return getToken(EffectParser.LT, 0); }
		public Operator_LTContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterOperator_LT(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitOperator_LT(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitOperator_LT(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class Operator_ASTERISKContext extends ExprContext {
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public TerminalNode ASTERISK() { return getToken(EffectParser.ASTERISK, 0); }
		public Operator_ASTERISKContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterOperator_ASTERISK(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitOperator_ASTERISK(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitOperator_ASTERISK(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class Operator_MINUSContext extends ExprContext {
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public TerminalNode MINUS() { return getToken(EffectParser.MINUS, 0); }
		public Operator_MINUSContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterOperator_MINUS(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitOperator_MINUS(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitOperator_MINUS(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class Operator_PARENContext extends ExprContext {
		public TerminalNode LEFT_PAREN() { return getToken(EffectParser.LEFT_PAREN, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public TerminalNode RIGHT_PAREN() { return getToken(EffectParser.RIGHT_PAREN, 0); }
		public Operator_PARENContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterOperator_PAREN(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitOperator_PAREN(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitOperator_PAREN(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class Operator_PLUSContext extends ExprContext {
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public TerminalNode PLUS() { return getToken(EffectParser.PLUS, 0); }
		public Operator_PLUSContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterOperator_PLUS(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitOperator_PLUS(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitOperator_PLUS(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class Operator_EQContext extends ExprContext {
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public TerminalNode EQ() { return getToken(EffectParser.EQ, 0); }
		public Operator_EQContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterOperator_EQ(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitOperator_EQ(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitOperator_EQ(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExprContext expr() throws RecognitionException {
		return expr(0);
	}

	private ExprContext expr(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		ExprContext _localctx = new ExprContext(_ctx, _parentState);
		ExprContext _prevctx = _localctx;
		int _startState = 18;
		enterRecursionRule(_localctx, 18, RULE_expr, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(132);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case STRING:
				{
				_localctx = new Operator_Expr0Context(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;

				setState(124);
				match(STRING);
				}
				break;
			case INT:
				{
				_localctx = new Operator_Expr1Context(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(125);
				match(INT);
				}
				break;
			case OBJECT:
				{
				_localctx = new Operator_Expr2Context(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(126);
				match(OBJECT);
				}
				break;
			case ID:
				{
				_localctx = new Operator_Expr4Context(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(127);
				match(ID);
				}
				break;
			case LEFT_PAREN:
				{
				_localctx = new Operator_PARENContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(128);
				match(LEFT_PAREN);
				setState(129);
				expr(0);
				setState(130);
				match(RIGHT_PAREN);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			_ctx.stop = _input.LT(-1);
			setState(169);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,16,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(167);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
					case 1:
						{
						_localctx = new Operator_EQContext(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(134);
						if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)");
						setState(135);
						match(EQ);
						setState(136);
						expr(17);
						}
						break;
					case 2:
						{
						_localctx = new Operator_COLONContext(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(137);
						if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)");
						setState(138);
						match(COLON);
						setState(139);
						expr(16);
						}
						break;
					case 3:
						{
						_localctx = new Operator_NEQContext(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(140);
						if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)");
						setState(141);
						match(NEQ);
						setState(142);
						expr(15);
						}
						break;
					case 4:
						{
						_localctx = new Operator_LTContext(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(143);
						if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)");
						setState(144);
						match(LT);
						setState(145);
						expr(14);
						}
						break;
					case 5:
						{
						_localctx = new Operator_LTEContext(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(146);
						if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)");
						setState(147);
						match(LTE);
						setState(148);
						expr(13);
						}
						break;
					case 6:
						{
						_localctx = new Operator_GTContext(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(149);
						if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)");
						setState(150);
						match(GT);
						setState(151);
						expr(12);
						}
						break;
					case 7:
						{
						_localctx = new Operator_GTEContext(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(152);
						if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)");
						setState(153);
						match(GTE);
						setState(154);
						expr(11);
						}
						break;
					case 8:
						{
						_localctx = new Operator_ASTERISKContext(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(155);
						if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)");
						setState(156);
						match(ASTERISK);
						setState(157);
						expr(10);
						}
						break;
					case 9:
						{
						_localctx = new Operator_SLASHContext(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(158);
						if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)");
						setState(159);
						match(SLASH);
						setState(160);
						expr(9);
						}
						break;
					case 10:
						{
						_localctx = new Operator_PLUSContext(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(161);
						if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
						setState(162);
						match(PLUS);
						setState(163);
						expr(8);
						}
						break;
					case 11:
						{
						_localctx = new Operator_MINUSContext(new ExprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(164);
						if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
						setState(165);
						match(MINUS);
						setState(166);
						expr(7);
						}
						break;
					}
					} 
				}
				setState(171);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,16,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	public static class Set_exprContext extends ParserRuleContext {
		public Set_exprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_set_expr; }
	 
		public Set_exprContext() { }
		public void copyFrom(Set_exprContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class SetExprContext extends Set_exprContext {
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(EffectParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(EffectParser.COMMA, i);
		}
		public SetExprContext(Set_exprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterSetExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitSetExpr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitSetExpr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Set_exprContext set_expr() throws RecognitionException {
		Set_exprContext _localctx = new Set_exprContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_set_expr);
		int _la;
		try {
			_localctx = new SetExprContext(_localctx);
			enterOuterAlt(_localctx, 1);
			{
			setState(172);
			expr(0);
			setState(177);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(173);
				match(COMMA);
				setState(174);
				expr(0);
				}
				}
				setState(179);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Where_exprContext extends ParserRuleContext {
		public Where_exprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_where_expr; }
	 
		public Where_exprContext() { }
		public void copyFrom(Where_exprContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class WhereExprOrContext extends Where_exprContext {
		public List<Where_exprContext> where_expr() {
			return getRuleContexts(Where_exprContext.class);
		}
		public Where_exprContext where_expr(int i) {
			return getRuleContext(Where_exprContext.class,i);
		}
		public List<TerminalNode> OR() { return getTokens(EffectParser.OR); }
		public TerminalNode OR(int i) {
			return getToken(EffectParser.OR, i);
		}
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public WhereExprOrContext(Where_exprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterWhereExprOr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitWhereExprOr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitWhereExprOr(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class WhereExpr_PARENContext extends Where_exprContext {
		public TerminalNode LEFT_PAREN() { return getToken(EffectParser.LEFT_PAREN, 0); }
		public Where_exprContext where_expr() {
			return getRuleContext(Where_exprContext.class,0);
		}
		public TerminalNode RIGHT_PAREN() { return getToken(EffectParser.RIGHT_PAREN, 0); }
		public WhereExpr_PARENContext(Where_exprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterWhereExpr_PAREN(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitWhereExpr_PAREN(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitWhereExpr_PAREN(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class WhereExprObjectContext extends Where_exprContext {
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public WhereExprObjectContext(Where_exprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterWhereExprObject(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitWhereExprObject(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitWhereExprObject(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class WhereExprAndContext extends Where_exprContext {
		public List<Where_exprContext> where_expr() {
			return getRuleContexts(Where_exprContext.class);
		}
		public Where_exprContext where_expr(int i) {
			return getRuleContext(Where_exprContext.class,i);
		}
		public List<TerminalNode> AND() { return getTokens(EffectParser.AND); }
		public TerminalNode AND(int i) {
			return getToken(EffectParser.AND, i);
		}
		public List<ExprContext> expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public WhereExprAndContext(Where_exprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).enterWhereExprAnd(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof EffectParserListener ) ((EffectParserListener)listener).exitWhereExprAnd(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof EffectParserVisitor ) return ((EffectParserVisitor<? extends T>)visitor).visitWhereExprAnd(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Where_exprContext where_expr() throws RecognitionException {
		return where_expr(0);
	}

	private Where_exprContext where_expr(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		Where_exprContext _localctx = new Where_exprContext(_ctx, _parentState);
		Where_exprContext _prevctx = _localctx;
		int _startState = 22;
		enterRecursionRule(_localctx, 22, RULE_where_expr, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(186);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
			case 1:
				{
				_localctx = new WhereExpr_PARENContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;

				setState(181);
				match(LEFT_PAREN);
				setState(182);
				where_expr(0);
				setState(183);
				match(RIGHT_PAREN);
				}
				break;
			case 2:
				{
				_localctx = new WhereExprObjectContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(185);
				expr(0);
				}
				break;
			}
			_ctx.stop = _input.LT(-1);
			setState(218);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,24,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(216);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) {
					case 1:
						{
						_localctx = new WhereExprAndContext(new Where_exprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_where_expr);
						setState(188);
						if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
						setState(191); 
						_errHandler.sync(this);
						_alt = 1;
						do {
							switch (_alt) {
							case 1:
								{
								{
								setState(189);
								match(AND);
								setState(190);
								expr(0);
								}
								}
								break;
							default:
								throw new NoViableAltException(this);
							}
							setState(193); 
							_errHandler.sync(this);
							_alt = getInterpreter().adaptivePredict(_input,19,_ctx);
						} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
						}
						break;
					case 2:
						{
						_localctx = new WhereExprOrContext(new Where_exprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_where_expr);
						setState(195);
						if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
						setState(198); 
						_errHandler.sync(this);
						_alt = 1;
						do {
							switch (_alt) {
							case 1:
								{
								{
								setState(196);
								match(OR);
								setState(197);
								expr(0);
								}
								}
								break;
							default:
								throw new NoViableAltException(this);
							}
							setState(200); 
							_errHandler.sync(this);
							_alt = getInterpreter().adaptivePredict(_input,20,_ctx);
						} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
						}
						break;
					case 3:
						{
						_localctx = new WhereExprAndContext(new Where_exprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_where_expr);
						setState(202);
						if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
						setState(205); 
						_errHandler.sync(this);
						_alt = 1;
						do {
							switch (_alt) {
							case 1:
								{
								{
								setState(203);
								match(AND);
								setState(204);
								where_expr(0);
								}
								}
								break;
							default:
								throw new NoViableAltException(this);
							}
							setState(207); 
							_errHandler.sync(this);
							_alt = getInterpreter().adaptivePredict(_input,21,_ctx);
						} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
						}
						break;
					case 4:
						{
						_localctx = new WhereExprOrContext(new Where_exprContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_where_expr);
						setState(209);
						if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
						setState(212); 
						_errHandler.sync(this);
						_alt = 1;
						do {
							switch (_alt) {
							case 1:
								{
								{
								setState(210);
								match(OR);
								setState(211);
								where_expr(0);
								}
								}
								break;
							default:
								throw new NoViableAltException(this);
							}
							setState(214); 
							_errHandler.sync(this);
							_alt = getInterpreter().adaptivePredict(_input,22,_ctx);
						} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
						}
						break;
					}
					} 
				}
				setState(220);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,24,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
		switch (ruleIndex) {
		case 3:
			return aimObject_sempred((AimObjectContext)_localctx, predIndex);
		case 9:
			return expr_sempred((ExprContext)_localctx, predIndex);
		case 11:
			return where_expr_sempred((Where_exprContext)_localctx, predIndex);
		}
		return true;
	}
	private boolean aimObject_sempred(AimObjectContext _localctx, int predIndex) {
		switch (predIndex) {
		case 0:
			return precpred(_ctx, 4);
		case 1:
			return precpred(_ctx, 3);
		case 2:
			return precpred(_ctx, 2);
		case 3:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean expr_sempred(ExprContext _localctx, int predIndex) {
		switch (predIndex) {
		case 4:
			return precpred(_ctx, 16);
		case 5:
			return precpred(_ctx, 15);
		case 6:
			return precpred(_ctx, 14);
		case 7:
			return precpred(_ctx, 13);
		case 8:
			return precpred(_ctx, 12);
		case 9:
			return precpred(_ctx, 11);
		case 10:
			return precpred(_ctx, 10);
		case 11:
			return precpred(_ctx, 9);
		case 12:
			return precpred(_ctx, 8);
		case 13:
			return precpred(_ctx, 7);
		case 14:
			return precpred(_ctx, 6);
		}
		return true;
	}
	private boolean where_expr_sempred(Where_exprContext _localctx, int predIndex) {
		switch (predIndex) {
		case 15:
			return precpred(_ctx, 4);
		case 16:
			return precpred(_ctx, 3);
		case 17:
			return precpred(_ctx, 2);
		case 18:
			return precpred(_ctx, 1);
		}
		return true;
	}

	public static final String _serializedATN =
		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3&\u00e0\4\2\t\2\4"+
		"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
		"\13\4\f\t\f\4\r\t\r\3\2\3\2\7\2\35\n\2\f\2\16\2 \13\2\3\2\3\2\3\2\3\2"+
		"\3\2\3\2\3\2\3\2\5\2*\n\2\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\4\3\4"+
		"\5\4\67\n\4\3\5\3\5\3\5\3\5\3\5\5\5>\n\5\3\5\3\5\3\5\3\5\3\5\3\5\6\5F"+
		"\n\5\r\5\16\5G\3\5\3\5\3\5\6\5M\n\5\r\5\16\5N\3\5\3\5\3\5\6\5T\n\5\r\5"+
		"\16\5U\7\5X\n\5\f\5\16\5[\13\5\3\6\3\6\3\6\5\6`\n\6\3\7\3\7\3\7\3\7\3"+
		"\7\3\7\3\7\5\7i\n\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\5\br\n\b\3\t\3\t\3\t\5"+
		"\tw\n\t\3\n\3\n\3\n\5\n|\n\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3"+
		"\13\5\13\u0087\n\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13"+
		"\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13"+
		"\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\7\13\u00aa\n\13\f\13\16"+
		"\13\u00ad\13\13\3\f\3\f\3\f\7\f\u00b2\n\f\f\f\16\f\u00b5\13\f\3\r\3\r"+
		"\3\r\3\r\3\r\3\r\5\r\u00bd\n\r\3\r\3\r\3\r\6\r\u00c2\n\r\r\r\16\r\u00c3"+
		"\3\r\3\r\3\r\6\r\u00c9\n\r\r\r\16\r\u00ca\3\r\3\r\3\r\6\r\u00d0\n\r\r"+
		"\r\16\r\u00d1\3\r\3\r\3\r\6\r\u00d7\n\r\r\r\16\r\u00d8\7\r\u00db\n\r\f"+
		"\r\16\r\u00de\13\r\3\r\2\5\b\24\30\16\2\4\6\b\n\f\16\20\22\24\26\30\2"+
		"\2\2\u0102\2)\3\2\2\2\4+\3\2\2\2\6\66\3\2\2\2\b=\3\2\2\2\n_\3\2\2\2\f"+
		"h\3\2\2\2\16q\3\2\2\2\20v\3\2\2\2\22{\3\2\2\2\24\u0086\3\2\2\2\26\u00ae"+
		"\3\2\2\2\30\u00bc\3\2\2\2\32\36\5\4\3\2\33\35\5\2\2\2\34\33\3\2\2\2\35"+
		" \3\2\2\2\36\34\3\2\2\2\36\37\3\2\2\2\37*\3\2\2\2 \36\3\2\2\2!\"\7\n\2"+
		"\2\"#\7\17\2\2#$\5\24\13\2$%\7\20\2\2%&\7\21\2\2&\'\5\2\2\2\'(\7\22\2"+
		"\2(*\3\2\2\2)\32\3\2\2\2)!\3\2\2\2*\3\3\2\2\2+,\5\6\4\2,-\5\b\5\2-.\5"+
		"\n\6\2./\5\f\7\2/\60\5\16\b\2\60\61\5\20\t\2\61\62\5\22\n\2\62\63\7\f"+
		"\2\2\63\5\3\2\2\2\64\67\7\3\2\2\65\67\7\4\2\2\66\64\3\2\2\2\66\65\3\2"+
		"\2\2\67\7\3\2\2\289\b\5\1\29>\7#\2\2:>\7$\2\2;>\7\"\2\2<>\7!\2\2=8\3\2"+
		"\2\2=:\3\2\2\2=;\3\2\2\2=<\3\2\2\2>Y\3\2\2\2?@\f\6\2\2@A\7\13\2\2AX\7"+
		"!\2\2BE\f\5\2\2CD\7\24\2\2DF\5\b\5\2EC\3\2\2\2FG\3\2\2\2GE\3\2\2\2GH\3"+
		"\2\2\2HX\3\2\2\2IL\f\4\2\2JK\7\24\2\2KM\7\"\2\2LJ\3\2\2\2MN\3\2\2\2NL"+
		"\3\2\2\2NO\3\2\2\2OX\3\2\2\2PS\f\3\2\2QR\7\24\2\2RT\7!\2\2SQ\3\2\2\2T"+
		"U\3\2\2\2US\3\2\2\2UV\3\2\2\2VX\3\2\2\2W?\3\2\2\2WB\3\2\2\2WI\3\2\2\2"+
		"WP\3\2\2\2X[\3\2\2\2YW\3\2\2\2YZ\3\2\2\2Z\t\3\2\2\2[Y\3\2\2\2\\]\7\5\2"+
		"\2]`\5\26\f\2^`\3\2\2\2_\\\3\2\2\2_^\3\2\2\2`\13\3\2\2\2ab\7\6\2\2bi\7"+
		"#\2\2cd\7\6\2\2di\7\"\2\2ef\7\6\2\2fi\7!\2\2gi\3\2\2\2ha\3\2\2\2hc\3\2"+
		"\2\2he\3\2\2\2hg\3\2\2\2i\r\3\2\2\2jk\7\7\2\2kr\7#\2\2lm\7\7\2\2mr\7\""+
		"\2\2no\7\7\2\2or\7!\2\2pr\3\2\2\2qj\3\2\2\2ql\3\2\2\2qn\3\2\2\2qp\3\2"+
		"\2\2r\17\3\2\2\2st\7\b\2\2tw\5\30\r\2uw\3\2\2\2vs\3\2\2\2vu\3\2\2\2w\21"+
		"\3\2\2\2xy\7\t\2\2y|\5\26\f\2z|\3\2\2\2{x\3\2\2\2{z\3\2\2\2|\23\3\2\2"+
		"\2}~\b\13\1\2~\u0087\7%\2\2\177\u0087\7$\2\2\u0080\u0087\7\"\2\2\u0081"+
		"\u0087\7!\2\2\u0082\u0083\7\17\2\2\u0083\u0084\5\24\13\2\u0084\u0085\7"+
		"\20\2\2\u0085\u0087\3\2\2\2\u0086}\3\2\2\2\u0086\177\3\2\2\2\u0086\u0080"+
		"\3\2\2\2\u0086\u0081\3\2\2\2\u0086\u0082\3\2\2\2\u0087\u00ab\3\2\2\2\u0088"+
		"\u0089\f\22\2\2\u0089\u008a\7\25\2\2\u008a\u00aa\5\24\13\23\u008b\u008c"+
		"\f\21\2\2\u008c\u008d\7\23\2\2\u008d\u00aa\5\24\13\22\u008e\u008f\f\20"+
		"\2\2\u008f\u0090\7\26\2\2\u0090\u00aa\5\24\13\21\u0091\u0092\f\17\2\2"+
		"\u0092\u0093\7\27\2\2\u0093\u00aa\5\24\13\20\u0094\u0095\f\16\2\2\u0095"+
		"\u0096\7\30\2\2\u0096\u00aa\5\24\13\17\u0097\u0098\f\r\2\2\u0098\u0099"+
		"\7\31\2\2\u0099\u00aa\5\24\13\16\u009a\u009b\f\f\2\2\u009b\u009c\7\32"+
		"\2\2\u009c\u00aa\5\24\13\r\u009d\u009e\f\13\2\2\u009e\u009f\7\37\2\2\u009f"+
		"\u00aa\5\24\13\f\u00a0\u00a1\f\n\2\2\u00a1\u00a2\7 \2\2\u00a2\u00aa\5"+
		"\24\13\13\u00a3\u00a4\f\t\2\2\u00a4\u00a5\7\35\2\2\u00a5\u00aa\5\24\13"+
		"\n\u00a6\u00a7\f\b\2\2\u00a7\u00a8\7\36\2\2\u00a8\u00aa\5\24\13\t\u00a9"+
		"\u0088\3\2\2\2\u00a9\u008b\3\2\2\2\u00a9\u008e\3\2\2\2\u00a9\u0091\3\2"+
		"\2\2\u00a9\u0094\3\2\2\2\u00a9\u0097\3\2\2\2\u00a9\u009a\3\2\2\2\u00a9"+
		"\u009d\3\2\2\2\u00a9\u00a0\3\2\2\2\u00a9\u00a3\3\2\2\2\u00a9\u00a6\3\2"+
		"\2\2\u00aa\u00ad\3\2\2\2\u00ab\u00a9\3\2\2\2\u00ab\u00ac\3\2\2\2\u00ac"+
		"\25\3\2\2\2\u00ad\u00ab\3\2\2\2\u00ae\u00b3\5\24\13\2\u00af\u00b0\7\16"+
		"\2\2\u00b0\u00b2\5\24\13\2\u00b1\u00af\3\2\2\2\u00b2\u00b5\3\2\2\2\u00b3"+
		"\u00b1\3\2\2\2\u00b3\u00b4\3\2\2\2\u00b4\27\3\2\2\2\u00b5\u00b3\3\2\2"+
		"\2\u00b6\u00b7\b\r\1\2\u00b7\u00b8\7\17\2\2\u00b8\u00b9\5\30\r\2\u00b9"+
		"\u00ba\7\20\2\2\u00ba\u00bd\3\2\2\2\u00bb\u00bd\5\24\13\2\u00bc\u00b6"+
		"\3\2\2\2\u00bc\u00bb\3\2\2\2\u00bd\u00dc\3\2\2\2\u00be\u00c1\f\6\2\2\u00bf"+
		"\u00c0\7\34\2\2\u00c0\u00c2\5\24\13\2\u00c1\u00bf\3\2\2\2\u00c2\u00c3"+
		"\3\2\2\2\u00c3\u00c1\3\2\2\2\u00c3\u00c4\3\2\2\2\u00c4\u00db\3\2\2\2\u00c5"+
		"\u00c8\f\5\2\2\u00c6\u00c7\7\33\2\2\u00c7\u00c9\5\24\13\2\u00c8\u00c6"+
		"\3\2\2\2\u00c9\u00ca\3\2\2\2\u00ca\u00c8\3\2\2\2\u00ca\u00cb\3\2\2\2\u00cb"+
		"\u00db\3\2\2\2\u00cc\u00cf\f\4\2\2\u00cd\u00ce\7\34\2\2\u00ce\u00d0\5"+
		"\30\r\2\u00cf\u00cd\3\2\2\2\u00d0\u00d1\3\2\2\2\u00d1\u00cf\3\2\2\2\u00d1"+
		"\u00d2\3\2\2\2\u00d2\u00db\3\2\2\2\u00d3\u00d6\f\3\2\2\u00d4\u00d5\7\33"+
		"\2\2\u00d5\u00d7\5\30\r\2\u00d6\u00d4\3\2\2\2\u00d7\u00d8\3\2\2\2\u00d8"+
		"\u00d6\3\2\2\2\u00d8\u00d9\3\2\2\2\u00d9\u00db\3\2\2\2\u00da\u00be\3\2"+
		"\2\2\u00da\u00c5\3\2\2\2\u00da\u00cc\3\2\2\2\u00da\u00d3\3\2\2\2\u00db"+
		"\u00de\3\2\2\2\u00dc\u00da\3\2\2\2\u00dc\u00dd\3\2\2\2\u00dd\31\3\2\2"+
		"\2\u00de\u00dc\3\2\2\2\33\36)\66=GNUWY_hqv{\u0086\u00a9\u00ab\u00b3\u00bc"+
		"\u00c3\u00ca\u00d1\u00d8\u00da\u00dc";
	public static final ATN _ATN =
		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
		}
	}
}